perm filename DTA11.2[KL,SYS] blob
sn#209156 filedate 1976-04-03 generic text, type C, neo UTF8
COMMENT ā VALID 00021 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00002 00002 MODIFICATION HISTORY
C00003 00003
C00005 00004
C00007 00005
C00009 00006
C00011 00007
C00015 00008
C00017 00009
C00020 00010
C00022 00011
C00024 00012
C00027 00013
C00030 00014
C00031 00015
C00033 00016
C00035 00017
C00036 00018
C00038 00019
C00041 00020
C00042 00021
C00046 ENDMK
Cā;
;;;MODIFICATION HISTORY
;;;
;;; 15 NOV 75 OBTAINED FROM DEC (KLDCP REV 7)
;;; 15 NOV 75 CONVERTED TO PALX FORMAT
;;;
.SBTTL PROGRAM FILE LOADER, 4-SEPT-75
;LOAD CONTROL FLAG WORD "LDCNTL"
;BIT15=1 IS HELP, PRINT FILE READ
;WORD = 0 .A10, PDP-10 LOAD
; 1 .A11, PDP-11 LOAD
; 2 .RAM, KL10 C-RAM ZERO
; 3 .RAM, KL10 C-RAM LOAD
; 4 .RAM, KL10 D-RAM LOAD
; 5 .BIN, PDP-11 BIN LOAD
;ACT10 .BIN LOADED AS .A11
; .SAV LOADED AS .A10
;PROGRAM DETERMINATION & LOAD CONTROL INITIALIZATION
DVLOAD: NAMEXT ;SETUP NAME.EXT
96$: TST R0 ;ANY EXT ?
BNE 4$ ;YES
TSTB JFILEF ;DOING "J" COMMAND ?
BEQ 50$ ;NO
MOV #"CM,R4 ;YES, DEFAULT EXT IS "CMD"
MOV #"D ,R5
BR 52$
50$: TSTB IFILEF ;DOING "I" COMMAND ?
BEQ 51$ ;NO
MOV #"CC,R4 ;YES, DEFAULT EXT IS "CCL"
MOV #"L ,R5
BR 52$
51$: MOV #"A1,R4 ;IF NO EXT, USE "A10"
MOV #"0 ,R5
52$: MOV R4,EXTBF
MOV R5,EXTBF+2
4$: MOV #LDCNTL,R3
TST (R3) ;IS THIS "HELP"
BMI 12$ ;BR IF YES
MOV #TEMP+1,R4
MOV #EXTBF+2,R5
MOVB (R5),(R4) ;MAKE A WORD OUT OF 2ND & 3RD CHAR
MOVB -(R5),-(R4)
CMPB #'A,-(R5) ;IS FIRST CHAR AN "A" ?
BEQ 6$ ;BR IF YES
CMPB #'B,(R5) ;IS FIRST CHAR A "B" ?
BEQ 14$ ;BR IF YES
CMPB #'S,(R5) ;IS FIRST CHAR AN "S" ?
BEQ 16$ ;BR IF YES
CMPB #'R,(R5) ;IS FIRST CHAR AN "R" ?
BEQ 6$ ;BR IF YES
5$: TST LDOVRD ;ANY LOAD EXT OVERRIDE ?
BNE 12$ ;YES
BR $$$NAM ;NAME.EXT ERR
6$: CMP #"10,(R4)
BEQ 7$ ;BR IF ".A10"
CMP #"11,(R4)
BEQ 8$ ;BR IF ".A11"
CMP #"AM,(R4)
BEQ 9$ ;BR IF ".RAM"
BR 5$ ;NONE, REPORT ERROR
7$: CLR (R3) ;SETUP LOAD CONTROL
BR 12$
8$: MOV #1,(R3)
BR 12$
9$: MOV #2,(R3)
12$: TST LDOVRD ;ANY LOAD EXT OVERRIDE ?
BEQ 20$ ;NO
MOV LDOVRD,R0 ;SET LOAD CONTROL ACCORDINGLY
DEC R0
MOV R0,(R3)
20$: JMP DEVFIL ;GO GET FILE & LOAD
14$: CMP #"IN,(R4) ;IS EXTENSION ".BIN" ?
BNE 5$ ;BR IF NO
MOV #5,(R3) ;YES, SET LOAD CONTROL
BR 12$
16$: CMP #"AV,(R4) ;IS EXTENSION ".SAV" ?
BEQ 7$ ;YES, ACT10 TREATS AS ".A10"
BR 5$
;PROCESS FILENAME.EXT FROM INPUT BUFFER
$NAMEXT:MOV #NAMBF,R0 ;CLEAR NAME LOOKUP BUFFER
MOV #20040,R1 ;TO SPACES
MOV #5,R2
70$: MOV R1,(R0)+ ;UP TO 9 CHARS
DEC R2
BGT 70$
MOV #NAMBF,R2 ;LOOKUP NAME
MOV #7,R1 ;MAXIMUM OF 6 CHARS IN NAME
TTISDL
BCS 99$ ;LETTER, ALREADY IN R0
1$: TTICHR ;GET CHAR FROM TTY BUFFER
BCS 5$
99$: CMPB #'.,R0
BEQ 2$ ;BR IF PERIOD, NAME.EXT SEPARATOR
CMPB #33,R0
BEQ 97$ ;ALTMODE, SELF START
CMPB #15,R0
BEQ 96$ ;CR, NO EXTENSION
CMPB #SPACE,R0 ;IF SPACE, NO EXT
BEQ 96$
DEC R1
BEQ 5$ ;BR IF MORE THAN 6 CHARS
MOVB R0,(R2)+ ;STORE CHAR
BR 1$
2$: MOV #EXTBF,R2 ;GET EXTENSION
MOV #4,R1
3$: TTICHR
BCS 5$
CMPB #33,R0
BEQ 13$ ;BR IF ALTMODE
CMPB #15,R0
BEQ 98$ ;BR IF CR
CMPB #SPACE,R0 ;BR IF SPACE
BEQ 98$
DEC R1
BEQ 5$ ;BR IF MORE THAN 3 CHARS
MOVB R0,(R2)+ ;STORE CHAR
BR 3$
97$: COM SRTFLG ;SET SELF START FLAG
BR 96$
13$: COM SRTFLG
98$: CMP #4,R1
BNE 10$
96$: CLR R0
10$: EXIT
$$$NAM=.
5$: $PMSG ;NAME.EXT ERR
$$NAM
JMP $CNTLC
$$NAM: .ASCIZ /NAME.EXT ERR/
.EVEN
;DECTAPE/RP04/FLOPPY LOADER START
DTRPLD: MOV #-1,DEVLC
CMP #5,LDCNTL ;PDP-11 .BIN FILE LOAD ?
BNE LLD1
JMP LDBIN
LLD1: DVDATA ;LOAD FIRST BUFFER
BCC LLD2
JMP DVEOF ;EOF
LLD2: TST DEVTYP
BPL 1$
JMP ACTLD2 ;ACT10 PROCESS
1$: MOV #$INBUF,R5 ;SET UP START OF CHAR BUFFER
MOV R5,$INPTC
LLD3: MOV DVCNT,R4 ;SETUP DEVICE BYTE COUNTER
MOV DVADR,R3 ;SETUP DEVICE DATA BLOCK ADDRESS
LLD4: TST R4 ;ANY DATA REMAINING ?
BGT 2$ ;YES
DVDATA ;NO, READ NEXT DEVICE BLOCK
BCC LLD3
JMP DVEOF ;END OF FILE ?
2$: MOVB (R3)+,R0 ;GET FRAME, ONE 7 BIT CHAR
DEC R4 ;COUNT IT
BIC #177600,R0
TST R0 ;IS FRAME A NULL ?
BEQ LLD4 ;BR IF YES, DON'T STORE
MOVB R0,(R5)+ ;STORE IN BUFFER
CMP R5,#$INBUF+140.
BLE 1$ ;BR IF BUFFER DIDN'T OVERFLOW
JMP $LINERR ;REPORT BUFFER OVERFLOW
1$: CMP #12,R0 ;IS CHAR A LINE FEED ?
BEQ LLDONE ;BR IF LINE DONE
BR LLD4 ;LOOP TILL LF FOUND
LDERR: JMP ACTLDF ;LOAD ERROR
LLDONE: MOV R4,DVCNT ;RESAVE POINTERS
MOV R3,DVADR
CLRB (R5) ;STORE A NULL TO END STRING
MOV R5,$INPTR
INC DEVLC ;COUNT LINE
MOV DEVLC,SWR ;DISPLAY (ON AN 11/40? I DOUBT IT - DAM)
TST LDCNTL ;IS HELP FLAG SET ?
BPL LDPROC ;BR IF NO
JMP DAHLP ;DTA/ACT HELP
LDPROC: CLR LDOCTF ;CLEAR OCTAL LOAD FLAG
CLR LDZBLK
MOV LDCNTL,R1 ;GET LOAD CONTROL
MOV $INPTC,R5 ;SETUP INPUT POINTER
MOVB (R5)+,R0 ;GET FIRST CHAR FROM FILE
CMPB #';,R0 ;IS FIRST CHAR A SEMICOLON ?
BEQ LDPRO1 ;YES, PROCESS COMMENT LINE
CMPB LDLTR(R1),R0 ;DOES 1ST CHAR MATCH LOAD TYPE ?
BEQ LDPRO3 ;YES
TST LDCNTL ;IS THIS .A10 FILE ?
BNE LDPRO2 ;NO, ERROR
CMPB #'Z,R0 ;YES, IS FIRST CHAR A "Z" ?
BNE LDPRO2 ;NO, ERROR
COM LDZBLK ;YES, SET CORE ZERO FLAG
BR LDPRO3
LDPRO1: TST DEVLC ;COMMENT, IS THIS FIRST LINE ?
BNE LLD2 ;NO
PUSH PCMDNF ;SAVE PGM CMD NO PRINT FLAG
SWITCH
BIT R0,#CHAIN ;IS CHAIN SWITCH SET ?
BEQ 1$ ;NO
MOV #-1,PCMDNF ;YES, PREVENT FILE ID PRINTOUT
1$: MOVB (R5)+,R1 ;PUT FILE ID LINE IN OUTPUT BUFFER
BEQ 2$ ;NULL, DONE
PLDBUF
BR 1$
2$: POP PCMDNF ;RESTORE FLAG
PNTRST ;RESET OUTPUT POINTERS ANYWAY
BR LLD2
LDPRO2: JMP ACTLDC ;LOAD TYPE ERROR
LDPRO3: MOVB (R5)+,R0 ;GET 2ND CHAR
CMPB #'O,R0 ;IS IT AN O ?
BEQ LDOCT ;YES, OCTAL DATA FORMAT LOAD
CMPB #40,R0 ;IS IT A SPACE ?
BNE LDPRO2 ;BR IF NO
LDCLR: MOV #LDCNT,R1 ;SETUP CONVERTED STORAGE ADDRESS
LDCNV: CLR R2 ;CLEAR WORD FORMER
1$: MOVB (R5)+,R0 ;GET CHAR
CMP #15,R0 ;IS IT A CR ?
BEQ 1$ ;YES, IGNORE
CMP #12,R0 ;IS IT A LF ?
BEQ LDEOL ;YES, END OF LINE
CMP #54,R0 ;IS IT A COMMA ?
BEQ 2$ ;YES, GO STORE WORD
TST LDOCTF ;LOADING OCTAL ?
BNE 3$ ;YES
SL R2,6 ;SHIFT WORD FORMER LEFT 6
BIC #100,R0 ;CLEAR ASCIIZED BIT
4$: BIS R0,R2 ;INSERT NEW BIT
BR 1$ ;LOOP TILL WORD FORMED
2$: MOV R2,(R1)+ ;STORE 16 BIT WORD
BR LDCNV ;GO DO NEXT
3$: SL R2,3 ;OCTAL LOAD
BIC #177770,R0 ;CLEAR ALL BUT NUMBER PART
BR 4$
LDOCT: COM LDOCTF ;OCTAL LOAD, SET FLAG
BR LDCLR
LDEOL: MOV R2,(R1) ;STORE CHECKSUM
LDCKSM: TST LDOCTF ;LOADING OCTAL ?
BNE 2$ ;YES, NO CHECKSUM
MOV #LDCNT,R2 ;CHECKSUM LOAD STORAGE
CLR R0
1$: ADD (R2)+,R0
CMP R2,R1
BLE 1$
TST R0 ;IS CHECKSUM = 0 ?
BEQ 2$ ;BR IF 0
JMP ACTBCK ;BAD CHECKSUM
2$: MOV LDCNTL,R0 ;DISPATCH TO PROPER LOAD ROUTINE
SL R0,1 ;DETERMINED FROM LDCNTL WORD
JMP @LDTYPE(R0)
LDTYPE: LDTEN ;.A10, LOAD TEN
LDELVN ;.A11, LOAD ELEVEN
LDCZRO ;.RAM, ZERO C-RAM
LDCRAM ;.RAM, LOAD C-RAM
LDDRAM ;.RAM, LOAD D-RAM
LDLTR: .ASCII /TEZCD/
$$LD11: .ASCIZ /11 ERR,ADR=/
$$COR: .ASCIZ /COR=/
$$ACT: .ASCIZ /ACT=/
$$RAM: .ASCIZ /\RAM ERR,COR=/
$$TEN: .ASCIZ /\10 ERR,ADR=/
.EVEN
$LINERR:PMSG <?LINE TOO LONG>
JMP $CNTLC
;LOAD DONE ROUTINE
LDDONE: TST DEVTYP ;LOAD DONE
BMI 1$ ;BR IF ACT10 MODE
JMP DADONE
1$: JMP ACTDON ;ACT10 PROCESS
;PDP-11 CORE LOAD ROUTINE
LDELVN: MOV LDCNT,R0 ;GET LOAD WORD COUNT
BEQ 2$ ;IF 0, THIS IS TRANSFER BLOCK
MOV #LDATA,R2 ;SETUP DATA PICKUP POINTER
MOV LDADR,R1 ;GET LOAD MEMORY ADDRESS
BIT #1,R1 ;LOAD WORD OR BYTE ?
BNE 3$ ;BYTE LOAD
1$: TST VERIFY
BNE 11$
19$: MOV (R2)+,(R1)+ ;MOVE WORD FROM STOR TO MEMORY
13$: DEC R0 ;DECREMENT WORD COUNT
BGT 1$ ;LOOP TILL ALL WORDS MOVED
18$: JMP LLD2 ;GO DO NEXT LOAD LINE
11$: CMP (R2),(R1) ;COMPARE CURRENT AGAINST FILE
BEQ 12$
PUSH R0
$PMSG
$$LD11 ;"11 ERR,ADR="
MOV R1,R0
PNTOCT
$PMSG
$$COR ;"COR="
MOV (R2),R0
PNTOCT
$PMSG
$$ACT ;"ACT="
MOV (R1),R0
PNTOCT
PCRLF
POP R0
12$: TST (R2)+
TST (R1)+
BR 13$
3$: TST VERIFY
BNE 31$
39$: MOVB (R2)+,(R1)+ ;ODD ADDRESS, BYTE LOAD
MOVB (R2)+,(R1)+ ;2 BYTES PER WORD
38$: DEC R0 ;DECREMENT WORD COUNT
BGT 3$ ;LOOP TILL ALL BYTES MOVED
BR 18$ ;GO ON TO NEXT
31$: CLR R5
32$: PUSH R0
CMPB (R2),(R1)
BEQ 33$
$PMSG
$$LD11 ;"11 ERR,ADR="
MOV R1,R0
PNTOCT
$PMSG
$$COR ;"COR="
MOVB (R2),R0
BIC #177400,R0
PNTOCS
PSPACE
$PMSG
$$ACT ;"ACT="
MOVB (R1),R0
BIC #177400,R0
PNTOCS
PCRLF
33$: POP R0
INC R2
INC R1
TST R5
BNE 38$
INC R5
BR 32$
2$: MOV LDADR,R0
LD11DN: MOV R0,PGOADR
CLR PGOCTL
BR LDDONE
;PDP-11 BINARY LOAD ROUTINE
LDBIN: DVDATA ;LOAD DEVICE BUFFER
LDBIN1: CLR $CKS11 ;INIT CHECKSUM
DVFRAM ;READ FRAME
DECB R0 ;CHECK FOR BLOCK START
BNE LDBIN1 ;NOT YET
DVFRAM ;READ ANOTHER FRAME
DVWRD ;GET FULL BYTE COUNT
MOV R0,LBC
SUB #6,LBC
BEQ LJMP ;BYTE COUNT OF 6 IS XFER BLOCK
DVWRD ;GET LOAD ADDRESS
MOV R0,R5 ;STORE LOAD ADDRESS
LDBIN2: DVFRAM ;READ DATA FRAME
DEC LBC
BGE LDBIN3 ;BR IF MORE DATA REMAINS
TSTB $CKS11 ;CORRECT CHECKSUM ?
BEQ LDBIN1 ;BR IF GOOD CHECKSUM
LDBINE: PMSG <\CKSUM ERR>
$LDBNE: JMP $CNTLC
LDBIN3: TST VERIFY
BNE 1$
CMP R5,#PRGSRT ;TRYING TO LOAD INTO KLDCP ?
BLO 10$ ;NO
PMSG <\ADR ERR>
BR $LDBNE ;YES, BAD !!
10$: MOVB R0,(R5)+ ;STORE DATA 1 BYTE AT A TIME
BR LDBIN2 ;LOOP
1$: CMPB R0,(R5)
BNE 3$
2$: INC R5
BR LDBIN2
3$: PUSH R0
$PMSG
$$LD11 ;"11 ERR,ADR="
MOV R5,R0
PNTOCT
$PMSG
$$COR ;"COR="
POP R0
PNTOCS
PSPACE
$PMSG
$$ACT ;"ACT="
MOVB (R5),R0
BIC #177400,R0
PNTOCS
PCRLF
BR 2$
LJMP: DVWRD ;GET POSSIBLE XFER ADDRESS
PUSH R0
DVFRAM
TSTB $CKS11 ;CORRECT CHECKSUM ?
BNE LDBINE ;BR IF BAD
POP R0 ;SETUP START ADDRESS
BR LD11DN
;KL10 LOAD D-RAM ROUTINE
;CALLS "WDRAM" WITH R0 = D-RAM ADDRESS
; R1 = LOAD DATA ADDRESS
LDDRAM: MOV LDCNT,R2 ;GET LOAD WORD COUNT
BEQ 2$ ;WC = 0, TRANSFER BLOCK
MOV LDADR,R3 ;SETUP D-RAM ADDRESS
MOV #LDATA,R4 ;DATA PICKUP ADDRESS
1$: MOV R3,R0 ;D-RAM ADDRESS TO R0
MOV R4,R1 ;DATA ADDRESS TO R1
TST VERIFY
BNE 11$ ;VERIFY D-RAM
WDRAM ;WRITE D-RAM
11$: MOV R3,R0
RDRAM ;READ D-RAM
MOV R0,R5
BIC #20,(R0) ;CLEAR COMPUTED PARITY
CMP (R0)+,(R1)+ ;COMPARE EVEN WORD
BNE 20$
BIC #20,(R0) ;CLEAR COMPUTED PARITY
CMP (R0)+,(R1)+ ;COMPARE ODD WORD
BNE 20$
CMP (R0),(R1) ;COMPARE COMMON WORD
BNE 20$
21$: ADD #2,R3 ;TO NEXT EVEN D-RAM ADDRESS
ADD #6,R4 ;SETUP NEXT DATA PICKUP ADR
SUB #3,R2 ;DECREMENT WORD COUNT
BGT 1$ ;BR IF NOT DONE YET
BR $LLD2 ;BACK FOR NEXT LOAD FILE LINE
2$: JMP LDDONE ;LOAD FINISHED
20$: $PMSG
$$RAM ;"RAM ERR,COR="
MOV R3,R0
MOV R4,R1
PNTDRM ;PRINT CORRECT D-RAM
$PMSG
$$ACT ;"ACT="
MOV R3,R0
MOV R5,R1
PNTDRM ;PRINT ACTUAL D-RAM
BR 21$ ;CONTINUE
;KL10 C-RAM ZERO
LDCZRO: MRESET ;MASTER RESET
TST VERIFY
BNE 2$ ;NO ZEROING IF VERIFY
MOV LDATA,R1 ;GET C-RAM ZERO COUNT
BEQ 2$ ;0 ZERO COUNT, BYPASS ZEROING C-RAM
MOV LDADR,R0 ;SETUP STARTING ADDRESS
MICNUL ;ZERO C-RAM
2$: INC LDCNTL ;ADVANCE LOAD CONTROL TO C-RAM LOAD
BR $LLD2
;KL10 LOAD C-RAM ROUTINE
;CALLS "WCRAM" WITH R0 = C-RAM ADDRESS
; R1 = DATA PICKUP ADDRESS
LDCRAM: MOV LDCNT,R2 ;GET LOAD WORD COUNT
BEQ 2$ ;WC = 0, TRANSFER BLOCK
MOV LDADR,R3 ;SETUP C-RAM ADDRESS
BIS #BIT14,R3 ;SET SPECIAL RESET BIT
MOV #LDATA,R4 ;DATA PICKUP ADDRESS
1$: TST LDOCTF ;LOADING OCTAL ?
BNE 3$ ;YES
4$: MOV R3,R0 ;C-RAM ADDRESS TO R0
MOV R4,R1 ;DATA PICKUP ADDRESS TO R1
TST VERIFY
BNE 41$
WCRAM ;WRITE C-RAM
41$: MOV R3,R0
RCRAM ;READ C-RAM BACK
MOV #6,R5
MOV R4,R1
11$: CMP (R0)+,(R1)+ ;RAM LOADED PROPERLY ?
BNE 12$ ;NO
DEC R5
BNE 11$
42$: INC R3 ;TO NEXT C-RAM ADDRESS
ADD #12.,R4 ;TO NEXT PICKUP ADDRESS
SUB #6,R2 ;DECREMENT WORD COUNT, 6 11 WDS PER
BGT 1$ ;BR IF NOT DONE YET
$LLD2=.
JMP LLD2 ;GET NEXT LOAD FILE LINE
2$: MOV LDADR,R0 ;SELECT C-RAM STARTING ADDRESS
WWADR ;WRITE ADDRESS TO C-RAM
INC LDCNTL ;ADVANCE LOAD CONTROL TO D-RAM LOAD
BR $LLD2
;OCTAL C-RAM LOAD, DATA IS BACKWARDS FROM UPSIDE DOWN NORMAL
3$: MOV (R4),R0 ;GET WORD 0
MOV 10(R4),(R4) ;PUT WORD 5 IN 0'S PLACE
MOV R0,10(R4) ;PUT WORD 0 IN 5'S PLACE
MOV 2(R4),R0 ;GET WORD 1
MOV 6(R4),2(R4) ;PUT WORD 4 IN 1'S PLACE
MOV R0,6(R4) ;PUT WORD 1 IN 4'S PLACE
BR 4$ ;NOW GO LOAD IN C-RAM
12$: $PMSG ;"RAM ERR,COR="
$$RAM
MOV R3,R0
MOV R4,R1
PNTCRM
PCRLF
$PMSG
$$ACT ;"ACT="
MOV R3,R0
MOV #$BUFRC,R1
PNTCRM
PCRLF
BR 42$
;LOAD TEN CORE ZERO
; START ADDRESS, LOW 16 BITS IN LDADR
; , BITS 18 & 19 IN HI-BYTE OF LDCNT
; ZERO COUNT IN LDATA
; WORD COUNT SIGNIFIES NUMBER OF LDATA WORDS USED FOR ZEROING
; "D10ZRO" - INCREMENTS PDP-10 ADDRESS WHILE ZEROING
LDTEN: MOV #L10ADR+2,R3 ;SETUP BLOCK START ADDRESS POINTER
CLR (R3)
MOVB LDCNT+1,(R3) ;HI-BYTE OF LDCNT IS ADR BITS 18 & 19
MOV LDADR,-(R3) ;SETUP ADR BITS 20-35
TST LDZBLK ;TEN CORE ZERO BLOCK ?
BEQ LDRDIN ;NO, LOAD DATA
LDTENZ: SM ;START MACHINE
BCC 3$
JMP .XCTER ;FAILED
3$: TST VERIFY
BNE 2$ ;DON'T ZERO IF VERIFY
MOV #LDATA,R4
MOVB LDCNT,R2 ;IS WC = 0 ?
BEQ 2$ ;YES, NO ZEROING
MOV R3,R1 ;SETUP ADDRESS
1$: MOV (R4)+,R0 ;SETUP ZERO COUNT
D10ZRO ;DEPOSIT ZEROS, CLEARING CORE
BCS LD10ER
MOV #.DPXAD,R1
DEC R2 ;COMPLETED ALL ZEROS ?
BNE 1$ ;NOT YET
2$: BR $LLD2 ;ALL REQUESTED CORE ZEROED.
;LOAD TEN DATA
;CALLS "DPOSVR" WITH R0 = LOAD DATA ADDRESS
; R1 = PDP-10 ADDRESS
LDRDIN: MOVB LDCNT,R2 ;GET LOAD WORD COUNT
BEQ 2$ ;WC = 0, TRANSFER BLOCK
MOV #LDATA,R4 ;DATA PICKUP ADDRESS
1$: MOV R3,R1
MOV R4,R0 ;SETUP DATA PICKUP ADDRESS
TST VERIFY
BNE LD10V
DPOSVR ;DEPOSIT & VERIFY
BCS LD10VR ;FAILED
$LRDIN=.
ADD #1,(R3)+ ;INCREMENT 10 ADDRESS
ADC (R3)
TST -(R3)
ADD #6,R4 ;SETUP NEXT DATA PICKUP ADDRESS
SUB #3,R2 ;DECREMENT WORD COUNT
BGT 1$ ;BR IF NOT DONE YET
BR $LLD2 ;BACK FOR NEXT LOAD FILE LINE
2$: MOV #PGOADR,R4
MOV (R3)+,(R4)+ ;TRANSFER START ADDRESS
MOV (R3),(R4) ;TO GO ADDRESS
MOV #2,PGOCTL
JMP LDDONE
LD10VR: BMI LD10ER ;N-BIT SET DEPOSIT FAILED
BEQ LD10ER ;Z-BIT SET, EXAMINE FAILED
LD10VE=.
PUSH R0
$PMSG ;"10 ERR,ADR="
$$TEN
MOV #L10ADR,R0
PNTADR
$PMSG
$$COR ;"COR="
MOV R4,R0
PNT36
$PMSG
$$ACT ;"ACT="
POP R0
PNT36
PCRLF
BR $LRDIN
LD10V: MOV R1,R0
EXAM ;EXAMINE PRESENT CONTENTS
BCS LD10ER ;CAN'T EXAMINE
MOV R0,R1
MOV R4,R0
CMPR36 ;COMPARE WITH LOAD FILE
BCC $LRDIN ;OK
BR LD10VE ;BAD
LD10ER: $PMSG ;"10 ERR,ADR="
$$TEN
MOV #L10ADR,R0
PNTADR
JMP $CNTLC
;DEVICE FILE DIRECTORY LOOKUP
DEVFIL: SETFLG ;INIT DEVICE LINE COUNT
DEVLC
TTPINI ;INIT TTY POINTERS
CLR $OUTBF
TST DEVTYP ;LOAD FROM WHAT DEVICE ?
BEQ DTFIL ; 0 = DECTAPE
BMI 1$ ; -1 = ACT10
JMP RPFIL ; 1 = RP04
1$: JMP ACTFIL
DTFIL: TST FLOPPY
BEQ 10$
RXFILE ;FLOPPY
BR 11$
10$: DTAFILE
11$: BCS 1$
JMP DTRPLD
1$: JMP $NONXF ;NON-EX FILE
;DECTAPE FORMAT
;FIRST DIRECTORY BLOCK = 102 (8)
;FILE DIRECTORY BLOCK
; LINK TO NEXT BLOCK
; 1 - FILE NAME 1
; 2 - FILE NAME 2
; 3 - FILE EXTENSION
; 4 - DATE
; 5 - SPARE
; 6 - START BLOCK #
; 7 - LENGTH
; 8 - END BLOCK #
; 9 - SPARE
;FILE DATA BLOCK
; LINK TO NEXT BLOCK
; 255 DATA WORDS
;DECTAPE PROGRAM FILE SEARCH
$DTAFILE:DTINIT ;DECTAPE INITIALIZATION
DTAFL1: TST FLOPPY
BEQ 20$
RXRDFL ;FLOPPY READ FILE
BR 21$
20$: DTRDFL ;READ UFD DIRECTORY BLOCK
21$: BCS 11$ ;EOF, CAN'T FIND FILE
MOV (R0),R0 ;PUT FIRST BUFFER ADR IN R0
MOV #28.,R1 ;28 ENTRIES IN DIRECTORY
1$: MOV (R0)+,DIRST0 ;STORE RAD50 NAME
MOV (R0)+,DIRST1
MOV (R0)+,DTEXT ;STORE RAD50 EXT
CMP (R0)+,(R0)+ ;SKIP 2 WORDS
MOV (R0)+,DTSTRT ;SAVE STARTING BLOCK #
MOV (R0)+,DTLNGTH ;SAVE LENGTH
CMP (R0)+,(R0)+ ;MOVE TO NEXT ENTRY
PUSH <R0,R1>
R50UPK ;UNPACK NAME
DIRST0,DIRST2
BCS 10$
R50UPK
DIRST1,DIRST3+1
BCS 10$
R50UPK ;UNPACK EXTENSION
DTEXT,DTEXTS
BCS 10$ ;ERROR RETURN
TST DVDIRF ;DOING "DIR" ?
BNE $DTDI1 ;YES
MOV #NAMBF,R3 ;LOAD ADDRESS OF INPUT DATA
MOV #DIRST2,R4 ;LOAD ADDRESS OF TABLE
MOV #6,R0 ;SET COUNT
3$: CMPB (R3)+,(R4)+ ;CHECK NAME DATA
BNE 10$ ;BR IF NOT SAME
DEC R0 ;DONE 6 TIMES ?
BNE 3$ ;BR IF NOT
MOV #EXTBF,R3 ;LOAD ADDRESS OF EXT INPUT
MOV #DTEXTS,R4 ;LOAD ADDRESS OF EXT STOR
MOV #3,R0 ;SET COUNT 3 CHARS
6$: CMPB (R3)+,(R4)+ ;CHECK EXT DATA
BNE 10$ ;BR IF NOT SAME
DEC R0 ;DONE 3 TIMES ?
BNE 6$ ;BR IF NOT
POP <R1,R0>
MOV DTSTRT,DVBUF ;LOAD STARTING BLOCK
EXIT ;NOW GO LOAD FILE
$DTDI2=.
10$: POP <R1,R0>
DEC R1 ;BEEN THROUGH 28 ENTRIES ?
BNE 1$ ;NOT YET
BR DTAFL1 ;TRY NEXT UFD BLOCK
11$: EXITERR
;DECTAPE/FLOPPY DIRECTORY ROUTINE
$DTDI1: CLR NAMBF
CLR DTEXT
CMP #020040,DIRST2 ;DON'T PRINT SPACES
BEQ 1$
$PMSG ;PRINT "FILE"
DIRST2
PSPACE
$PMSG ;PRINT "EXT"
DTEXTS
MOV #TAB,R0
PNTCHR
MOV DTLNGTH,R0
PNTDEC ;PRINT NUMBER OF BLOCKS
PCRLF
1$: BR $DTDI2 ;GO DO NEXT
$DI: TTITRM
PNORML
TST DEVTYP
BEQ $DTDIR ;DECTAPE
BMI 1$ ;ILLEGAL ON ACT10
JMP $RPDIR ;RP04
1$: JMP $CMDE
$DTDIR: SETFLG
DVDIRF ;SET DIRECTORY FLAG
TST FLOPPY
BEQ 1$
RXFILE ;FLOPPY
BR 2$
1$: DTAFILE
2$: JMP $CONSL
;READ DEVICE FRAME SUBROUTINE
$DVFRAM:TST DVCNT ;USED ALL DATA ?
BGT 1$ ;NO
DVDATA ;YES, READ NEXT BLOCK
BCS DVEOF ;EOF
1$: MOVB @DVADR,R0 ;GET ONE BYTE
INC DVADR ;INCREMENT PICKUP ADDRESS
DEC DVCNT ;COUNT IT
BIC #177400,R0 ;CLEAR JUNK, CHAR IS 8 BITS
ADD R0,$CKS11
BR $$DVX
;READ DEVICE BUFFER SUBROUTINE
$DVDATA:TST DEVTYP
BNE 4$
TST FLOPPY
BEQ 1$
RXRDFL ;FLOPPY
BR 11$
1$: DTRDFL ;DECTAPE READ
11$: BCS 3$ ;EOF
2$: MOV (R0)+,DVADR ;SAVE BUFFER ADDRESS
MOV (R0),DVCNT ;SAVE BUFFER BYTE COUNT
BR $$DVX
3$: EXITERR ;EOF
4$: MOV #FILDSB,R0
RPRDFL ;RP04 FILE DATA BLOCK READ
BCC 2$
CMP #1,R0 ;ERROR, EOF ?
BEQ DVEOF ;YES
RPERROR ;NO, JUST ERROR
DVEOF: TST LDCNTL ;EOF, PRINTING A HELP FILE ?
BMI 1$ ;YES
PMSG <\EOF ?>
JMP $CNTLC
1$: JMP DAHLPD
;ASSEMBLE ONE 16 BIT DATA WORD
$DVWRD: DVFRAM ;READ FRAME
MOV R0,LTMP
DVFRAM ;GET ANOTHER FRAME
SWAB R0 ;PLACE IN HIGH ORDER BYTE
BIS R0,LTMP ;PUT 2 BYTES TOGETHER
MOV LTMP,R0 ;PUT BACK IN R0
BR $$DVX
;DECTAPE INITIALIZATION
$DTINIT:MOV #102,DVBUF ;SET STARTING BLOCK NUMBER
$$DVX: EXIT
;FILE NOT FOUND
$NONXF: TST DIAFLG ;DOING "DIAMON" FILE SELECTION ?
BEQ 1$ ;NO
JMP DIANF ;YES, "DIAMON" FILE NOT FOUND
1$: PMSG <NON-EX FILE>
JMP $CNTLC
;RAD50 UNPACK SUBROUTINE
$R50UPK:ADD #4,12(SP) ;RETURN OVER TRAILING PARAMETERS
PUSH R0
MOV $EMADR,R5
MOV (R5)+,R4 ;RAD50 ADDRESS TO R4
MOV (R4),R4 ;RAD50 VALUE TO R4
MOV (R5),R3 ;STORE ADDRESS TO R3
MOV #2,R1
MOV #-1,-(6) ;SET STACK STOP
1$: MOV R4,-(6) ;SAVE PREVIOUS VALUE
CLR R4 ;CLEAR R4 FOR NEXT REMAINDER
2$: MOV (6),R0 ;TAKE 3/4 OF VALUE
BISB @PC,R0 ;???????
MOV R0,R2
ROR R2
ASR R2
SUB R2,R0
BIC #37,R0 ;PREPARE TO TAKE 1/4 OF RESULT
SUB R0,(6) ;BUT REDUCE ORIGINAL BY 3/4
ROR R0 ;GET 3/16 OF ORIGINAL
ASR R0
SUB R0,(6)
ADD R0,R4 ;THIS GIVES 1ST APPROXIMATION
CMP (6),#47 ;LOW AS POSSIBLE ?
BHI 2$ ;IF SO THIS IS BYTE REQUIRED
ASR R4
ASR R4
ASR R4
DEC R1 ;DONE 2 BYTES ?
BNE 1$ ;BR IF NOT
CMPB R4,#47 ;LAST BYTE TOO BIG ?
BHI 4$ ;IF YES, ERROR
3$: TSTB R4 ;SPACE ?
BEQ 6$ ;IF YES, ADD 40
CMPB R4,#35 ;IF UNUSED CODE ....
BNE 5$
4$: MOV #'X,R4 ;ASCII X TO R4
BR 9$ ;GO TO ERROR EXIT
5$: CMPB R4,#33 ;$ ?
BEQ 8$ ;IF YES, GO ADD 11
BHI 7$ ;FOR DIGIT OR DOT ADD 22
ADD #40,R4 ;FOR LETTER ADD 100
6$: ADD #16,R4
7$: ADD #11,R4
8$: ADD #11,R4
9$: MOVB R4,(3)+ ;STORE RESULT
MOV (6)+,R4 ;GET NEXT BYTE
BPL 3$ ;BR IF NOT STACK STOP
POP R0
$$$DVX: BR $$DVX
;DECTAPE READ/WRITE FILE ROUTINES
$DTRDFL:TST DVBUF ;ANY DATA BLOCKS REMAINING ?
BNE $DTRFL ;YES
$$DTXE: EXITERR ;NO
$DTRFL: MOV DVBUF,DTBLK ;SET REQUESTED BLOCK
MOV #DVBUF,CASAV ;SET BUFFER ADDRESS
MOV #-256.,WCSAV ;SET WORD COUNT
DTREAD ;DECTAPE READ
BCS $$DTXC ;FAILED
MOV #$DTINFO,R0
$$DTX: EXIT
$$DTXC: JMP $CNTLC ;FAILED
$DTWTFL:MOV #DVBUF,CASAV
MOV #-256.,WCSAV
DTWRT ;WRITE DECTAPE
BCC $$DTX ;OK
BR $$DTXC ;FAILED
$DTINFO:DVBUF+2 ;FIRST USABLE DATA WORD
510. ;BYTE COUNT
$DTBASE:MOV #DTBLK,R0 ;RETURN PARAMETER BASE ADDRESS
BR $$DTX
;DECTAPE DEVICE READ/WRITE ROUTINE
$DTREAD:MOV #TCRDATA+TCDO,R0
BR $DTXFR
$DTWRT: MOV #TCWDATA+TCDO,R0
$DTXFR: MOV R0,DTXCMD ;SAVE COMMAND
MOV #3,TRYCTR ;SET MAXIMUM TRY COUNT, 3.
$DTXF1: MOVB DTUNIT+1,R4 ;SETUP UNIT
MOV WCSAV,@#TCWC ;SETUP WORD COUNT
MOV CASAV,@#TCBA ;SETUP READ ADDRESS
MOV #TCRNUM+TCDO,R0
MOV #TCCM,R1
MOV #TCREV,R3
MOV DTBLK,R2 ;SETUP BLOCK # AND DIRECTION
BPL $DTXF2
NEG R2
ADD #10,R4 ;REVERSE, SET REV INDICATOR
BIS R3,R0 ;START UP IN REVERSE
$DTXF2: MOV #6,REVCNT ;SET MAXIMUM REVERSAL COUNT, 6.
CLR INTSW ;SET INTSW FOR SEARCH
$DTXF3: PUSH R3
JSR PC,$TIRDY ;ANY OPERATOR INTERRUPTS ?
BCS 2$ ;NO
MOVB $TICHR,R3 ;GET CHAR
BICB #200,R3
CMPB #CNTRLC,R3 ;IS IT CONTROL C ?
BNE 2$ ;NO
BIC #116,(R1) ;YES, STOP DECTAPE
JMP $TICC ;AND ABORT
2$: POP R3
BIS DTUNIT,R0 ;SELECT UNIT
MOV R0,(R1) ;SET TCCM
1$: BIT #TCERR+TCRDY,(R1) ;WAIT FOR DONE OR ERROR
BEQ 1$
BMI DTER ;BR IF ERROR
TSTB INTSW ;SEARCH OR TRANSFER ?
BNE DATINT ;BR IF TRANSFER
CMP @#TCDT,R2 ;BLOCK MATCH ?
BEQ DTSRF ;BR IF YES
BGT DTSRE ;BR IF LARGER
BIT R3,(R1) ;SMALLER, REVERSE ?
BEQ $DTXF3 ;FORWARD, CONTINUE DIRECTION
DTSRA: ADD #3,@#TCDT ;+3 TO TCDT
CMP @#TCDT,R2 ;LOWER BY 3 OR MORE ?
BLOS DTREV ;YES, GO REVERSE
BR $DTXF3 ;NO, CONTINUE DIRECTION
DTSRE: BIT R3,(R1) ;BLK HIGH, CHECK DIRECTION
BNE $DTXF3 ;BR IF REV, CONTINUE DIRECTION
SUB #3,@#TCDT ;FWD, -3 TO TCDT
CMP R2,@#TCDT ;HIGHER BY 3 OR MORE ?
BLE DTREV ;REVERSE IF HIGHER BY 3 OR MORE
BR $DTXF3 ;NO, CONTINUE DIRECTION
DTSRF: CMPB @#TCCM1,R4 ;BLOCK SAME, SAME DIRECTION ?
BNE $DTXF3 ;BR IF NOT, CONTINUE SEARCH
$DTXF4: COMB INTSW ;WANTED ???
MOVB DTXCMD,R0 ;SET UP XFER COMMAND
TST DTBLK
BPL $DTXF3 ;FORWARD READ
BIS R3,R0 ;REVERSE READ
BR $DTXF3
DTER: TSTB INTSW ;SEARCH OR XFER ?
BNE DTERA ;BR IF XFER
TST @#TCST ;END ZONE ?
BMI DTREV ;BR IF YES, TO REVERSE
DTERA: BIT #TCSOFT,@#TCST ;CHECK FOR SOFT ERROR
BEQ DTHDER ;BR IF NOT SOFT ERROR
DECB TRYCTR ;3RD TRY ?
BEQ $DTXF3 ;BR IF YES
BR $DTXF1 ;GO TRY AGAIN
DTERB: BIC #116,(R1) ;STOP DECTAPE
PMSG <?SOFT>
DTERC: PMSG < DTA ERR>
EXITERR
DTHDER: BIC #116,(R1) ;STOP DECTAPE
PMSG <?HARD>
BR DTERC
DTREV: ADD R3,R0 ;CHANGE DIRECTION
BIC #BIT12,R0
DTREVC: DECB REVCNT ;6TH REVERSAL ?
BNE $DTXF3 ;BR IF NOT
BIC #116,(R1) ;STOP DECTAPE
PMSG <?REV>
BR DTERC
DATINT: BIC #116,(R1) ;STOP DECTAPE
EXIT ;DONE